//
//  ViewController.swift
//  GCD_Swift
//
//  Created by liuyi on 2017/11/6.
//  Copyright © 2017年 liuyi. All rights reserved.
//

import UIKit
/*
 一. 基本概念:同步, 异步, 并发, 串行
 
 同步和异步决定了要不要开启新的线程
 1.同步(sync): 在当前线程中执行任务, 不具备开启新线程的能力
 2.异步(async): 在新的线程中执行任务, 具备开启新线程的能
 
 并发和串行决定了任务的执行方式
 1.并发(Concurrent): 多个任务并发(同时)执行
 2.串行(Serial): 一个任务执行完毕后, 再执行下一个任务(顺序执行)
 
 */


class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //一、队列
        
        //1.1 串行队列
        let queue1 = DispatchQueue.init(label: "Serial queue1")//label:队列标识符
        //如果想指定串行队列的优先级, 可使用下面的方法来创建:
        let queue2 = DispatchQueue.init(label: "QueueIdentifier", qos: DispatchQoS.userInitiated)
        /*
         参数qos: 用于指定队列的优先级, 是个枚举:
         
         .userInteractive //用户交互(跟主线程一样)
         .userInitiated   //用户期望优先级（不要放太耗时的操作）
         .default         //默认的
         .utility         //公共的
         .background      //后台
         .unspecified     //不指定
         
         优先级, 由上往下依次降低
         */
        
        //最常用的串行队列---主队列
        let mainQueue = DispatchQueue.main
        
        //1.2 并行队列
        
        //和创建串行队列的方法一样, 只不过多了一个参数attributes, 传 .concurrent 即可创建一个并行队列
        /*
         label 队列的标识符，方便调试
         qos  用于指定队列的优先级
         attributes 队列的属性
         autoreleaseFrequency。顾名思义，自动释放频率。有些队列是会在履行完任务后自动释放的，有些比如Timer等是不会自动释放的，是需要手动释放。
         */
        
        let queue3 = DispatchQueue.init(label: "com.leo.queue", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.workItem, target: nil)
        
        //在使用的时候, 我们一般不去创建并行队列, 而是使用系统为我们提供的全局的并行队列:
        let queue4 = DispatchQueue.global()
        //也可以制定优先级
        let queue5 = DispatchQueue.global(qos: .default)
        
        
        //注意:
        //在创建串行并行队列的时候, 参数attributes, 可以指定创建的是串行还是并行队列, 他还有一个值: .initiallyInactive, 即: 创建的时候, 是处于不活跃状态, 即不会执行任务, 需要手动调用activate()来激活队列执行任务;
        
        //方法调用
        //GCDTest1()
        //GCDTest2()
        //GCDTest3()
        //GCDTest4()
        //GCDTest5()
        //GCDTest6()
        GCDTest7()
    }

    //二、GCD常用的用法
    
    //2.1 开线程异步执行完耗时代码，返回主线程刷新UI
    func GCDTest1() {
        DispatchQueue.global().async {//并行、异步
             print("开一条全局队列异步执行任务")
            DispatchQueue.main.async {//串行、异步
                print("在主队列执行刷新界面任务")
            }
        }
    }
    
    //2.2 等待异步执行多个任务后, 再执行下一个任务
    func GCDTest2() {
        let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
        myQueue.async {//任务一
            for _ in 0...10 {
                 print("任务1......")
            }
        }
        myQueue.async {
            for _ in 0...5 {
                print("任务2++++++")
            }
        }
        // barrier 会等待上面执行完毕再执行下面的，会阻塞当前线程
        myQueue.async(group: nil, qos: .default, flags: .barrier, execute: {//2.
            print("000000")
        })
        
        myQueue.async {
            print("111111")
        }
    }
    
    //2.3 延时提交任务
    func GCDTest3() {
        print("延时提交的任务--GCDTest3")
        //主队列
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
            print("延时提交的任务--main")
        }
        
        //指定队列
        let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
        myQueue.asyncAfter(deadline: DispatchTime.now() + 3, execute: {
            print("延时提交的任务--myQueue")
        })
        
        let delayTime = DispatchTimeInterval.seconds(2)
        myQueue.asyncAfter(deadline: DispatchTime.now()+delayTime) {
            print("延时提交的任务--delayTime")

        }
    }
    
    
    //2.4 信号量--控制最大并发数
    
    /*
     信号量的说明:
     GCD 信号量控制并发 （dispatch_semaphore）
     当我们在处理一系列线程的时候，当数量达到一定量，在以前我们可能会选择使用NSOperationQueue来处理并发控制，但如何在GCD中快速的控制并发呢？答案就是dispatch_semaphore。
     信号量是一个整形值并且具有一个初始计数值，并且支持两个操作：信号通知和等待。当一个信号量被信号通知，其计数会被增加。当一个线程在一个信号量上等待时，线程会被阻塞（如果有必要的话），直至计数器大于零，然后线程会减少这个计数。
     在GCD中有三个函数是semaphore的操作，分别是：
     1、dispatch_semaphore_create　　　创建一个semaphore
     2、dispatch_semaphore_signal　　　发送一个信号
     3、dispatch_semaphore_wait　　　　等待信号
     
     关于信号量，一般可以用停车来比喻。
     　　停车场剩余4个车位，那么即使同时来了四辆车也能停的下。如果此时来了五辆车，那么就有一辆需要等待。
        信号量的值就相当于剩余车位的数目，dispatch_semaphore_wait函数就相当于来了一辆车，dispatch_semaphore_signal就相当于走了一辆车。
     停车位的剩余数目在初始化的时候就已经指明了（dispatch_semaphore_create（long value）），调用一次dispatch_semaphore_signal，剩余的车位就增加一个；调用一次dispatch_semaphore_wait剩余车位就减少一个；当剩余车位为0时，再来车（即调用dispatch_semaphore_wait）就只能等待。
     有可能同时有几辆车等待一个停车位。有些车主没有耐心，给自己设定了一段等待时间，这段时间内等不到停车位就走了，如果等到了就开进去停车。而有些车主就像把车停在这，所以就一直等下去。
     
     下面我们逐一介绍三个函数：
     （1）dispatch_semaphore_create的声明为：
     　　dispatch_semaphore_t dispatch_semaphore_create(long value);
     　　传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL。
     
     （2）dispatch_semaphore_signal的声明为：
     　　long dispatch_semaphore_signal(dispatch_semaphore_t dsema)这个函数会使传入的信号量dsema的值加1；（至于返回值，待会儿再讲）
     
     (3) dispatch_semaphore_wait的声明为：
     　　long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)；
     这个函数会使传入的信号量dsema的值减1。这个函数的作用是这样的，如果dsema信号量的值大于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；如果desema的值为0，那么这个函数就阻塞当前线程等待timeout（注意timeout的类型为dispatch_time_t，不能直接传入整形或float型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。
     
     （4）dispatch_semaphore_signal的返回值为long类型，当返回值为0时表示当前并没有线程等待其处理的信号量，其处理的信号量的值加1即可。当返回值不为0时，表示其当前有（一个或多个）线程等待其处理的信号量，并且该函数唤醒了一个等待的线程（当线程有优先级时，唤醒优先级最高的线程；否则随机唤醒）。
     　　dispatch_semaphore_wait的返回值也为long型。当其返回0时表示在timeout之前，该函数所处的线程被成功唤醒。当其返回不为0时，表示timeout发生。
     
     */
    
    //每十个任务并发执行
    func GCDTest4() {
        let group = DispatchGroup.init()
        let queue = DispatchQueue.global()
        //剩余10个车位
        let semaphore = DispatchSemaphore.init(value: 10)
        for i in 1...100 {
            
            //来了一辆车，信号量减1
            let result = semaphore.wait(timeout: .distantFuture)
            if result == .success {
                queue.async(group: group, execute: {
                    print("队列执行\(i)--\(Thread.current)")
                    //模拟执行任务时间
                    sleep(3)
                    //延迟3s后,走了一辆车，信号量+1
                    semaphore.signal()
                })
            }
        }
        group.wait()
    }
    
    //2.5 Group的用法
    //你想某个任务在其他任务执行之后再执行, 或者必须某个任务执行完,才能执行下面的任务, 可以使用DispatchGroup:
    
    //notify(依赖任务)
    func GCDTest5() {
        let group = DispatchGroup.init()
        let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
        myQueue.async(group: group, qos: .default, flags: []) {
            for _ in 0...10 {
                print("耗时任务1。。。。")
            }
        }
        myQueue.async(group: group, qos: .default, flags: []) {
            for _ in 0...10 {
                print("耗时任务2。。。。")
            }
        }
        //执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务
        group.notify(queue: myQueue) {
             print("notify--回到该队列中执行")
        }
    }
    
    
    func GCDTest6() {
        let queue = DispatchQueue(label: "queueName", attributes: .concurrent)
        queue.async {
            sleep(3)
            print("任务 1")
        }
        queue.async {
            sleep(2)
            print("任务 2")
        }
        queue.async {
            sleep(1)
            print("任务 3")
        }
        DispatchGroup.init().notify(qos: .default, flags: .barrier, queue: queue) {
            print("所有任务结束")
        }
        print("任务结束")
    }
    
    //wait(任务等待)
    func GCDTest7() {
        let group = DispatchGroup.init()
        let myQueue = DispatchQueue(label: "com.myQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)//并行队列
        myQueue.async(group: group, qos: .default, flags: []) {
            for _ in 0...10 {
                print("耗时任务1。。。。")
            }
        }
        myQueue.async(group: group, qos: .default, flags: []) {
            for _ in 0...10 {
                print("耗时任务2。。。。")
//                sleep(UInt32(1))//阻塞当前线程。一旦看到这句话，当前线程挂起给定时间后执行下一句
            }
        }
        //等待上面任务执行，会阻塞当前线程，超时就执行下面的，上面的继续执行。可以无限等待 .distantFuture
        let result = group.wait(timeout: .now() + 5.0)
        switch result {
        case .success:
            print("不超时, 上面的两个任务都执行完")
        case .timedOut:
            print("超时了, 上面的任务还没执行完执行这了")
        }
        print("接下来的操作")
    }
    
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }


    
    
}






































